I had a giant misunderstanding of what 'synchronizes with' meant in [futures.async]/p5. This invalidated the current design of async in <future>. This is a new design, based on my new understanding, which has been confirmed on the lwg mailing list. The summary is that ~future() (and ~shared_future()) will block when they are created from within async, and the thread hasn't finished yet. As part of this work I created two new type traits: __invokable<F, Args...>::value and __invoke_of<F, Args...>::type. These are what result_of<F(Args...)> wanted to be when it grew up, but never will be. __invoke_of is carefully crafted so that it can serve as its own enable_if (type doesn't exist if the signature isn't invokable). All of this work is C++11 only. git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@131639 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/include/future b/include/future index c60d3ac..471e1f2 100644 --- a/include/future +++ b/include/future
@@ -858,6 +858,115 @@ #endif // _LIBCPP_NO_EXCEPTIONS } +template <class _R, class _F> +class __async_assoc_state + : public __assoc_state<_R> +{ + typedef __assoc_state<_R> base; + + _F __func_; + + virtual void __on_zero_shared(); +public: +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + explicit __async_assoc_state(_F&& __f); +#endif + + virtual void __execute(); +}; + +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + +template <class _R, class _F> +inline _LIBCPP_INLINE_VISIBILITY +__async_assoc_state<_R, _F>::__async_assoc_state(_F&& __f) + : __func_(_STD::forward<_F>(__f)) +{ +} + +#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES + +template <class _R, class _F> +void +__async_assoc_state<_R, _F>::__execute() +{ +#ifndef _LIBCPP_NO_EXCEPTIONS + try + { +#endif // _LIBCPP_NO_EXCEPTIONS + this->set_value(__func_()); +#ifndef _LIBCPP_NO_EXCEPTIONS + } + catch (...) + { + this->set_exception(current_exception()); + } +#endif // _LIBCPP_NO_EXCEPTIONS +} + +template <class _R, class _F> +void +__async_assoc_state<_R, _F>::__on_zero_shared() +{ + this->wait(); + base::__on_zero_shared(); +} + +template <class _F> +class __async_assoc_state<void, _F> + : public __assoc_sub_state +{ + typedef __assoc_sub_state base; + + _F __func_; + + virtual void __on_zero_shared(); +public: +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + explicit __async_assoc_state(_F&& __f); +#endif + + virtual void __execute(); +}; + +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + +template <class _F> +inline _LIBCPP_INLINE_VISIBILITY +__async_assoc_state<void, _F>::__async_assoc_state(_F&& __f) + : __func_(_STD::forward<_F>(__f)) +{ +} + +#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES + +template <class _F> +void +__async_assoc_state<void, _F>::__execute() +{ +#ifndef _LIBCPP_NO_EXCEPTIONS + try + { +#endif // _LIBCPP_NO_EXCEPTIONS + __func_(); + this->set_value(); +#ifndef _LIBCPP_NO_EXCEPTIONS + } + catch (...) + { + this->set_exception(current_exception()); + } +#endif // _LIBCPP_NO_EXCEPTIONS +} + +template <class _F> +void +__async_assoc_state<void, _F>::__on_zero_shared() +{ + this->wait(); + base::__on_zero_shared(); +} + template <class> class promise; template <class> class shared_future; template <class> class atomic_future; @@ -874,6 +983,14 @@ __make_deferred_assoc_state(_F __f); #endif +template <class _R, class _F> +future<_R> +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES +__make_async_assoc_state(_F&& __f); +#else +__make_async_assoc_state(_F __f); +#endif + template <class _R> class _LIBCPP_VISIBLE future { @@ -885,11 +1002,16 @@ template <class> friend class shared_future; template <class> friend class atomic_future; - template <class _R1, class _F> #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + template <class _R1, class _F> friend future<_R1> __make_deferred_assoc_state(_F&& __f); + template <class _R1, class _F> + friend future<_R1> __make_async_assoc_state(_F&& __f); #else + template <class _R1, class _F> friend future<_R1> __make_deferred_assoc_state(_F __f); + template <class _R1, class _F> + friend future<_R1> __make_async_assoc_state(_F __f); #endif public: @@ -983,11 +1105,16 @@ template <class> friend class shared_future; template <class> friend class atomic_future; - template <class _R1, class _F> #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + template <class _R1, class _F> friend future<_R1> __make_deferred_assoc_state(_F&& __f); + template <class _R1, class _F> + friend future<_R1> __make_async_assoc_state(_F&& __f); #else + template <class _R1, class _F> friend future<_R1> __make_deferred_assoc_state(_F __f); + template <class _R1, class _F> + friend future<_R1> __make_async_assoc_state(_F __f); #endif public: @@ -1076,11 +1203,16 @@ template <class> friend class shared_future; template <class> friend class atomic_future; - template <class _R1, class _F> #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + template <class _R1, class _F> friend future<_R1> __make_deferred_assoc_state(_F&& __f); + template <class _R1, class _F> + friend future<_R1> __make_async_assoc_state(_F&& __f); #else + template <class _R1, class _F> friend future<_R1> __make_deferred_assoc_state(_F __f); + template <class _R1, class _F> + friend future<_R1> __make_async_assoc_state(_F __f); #endif public: @@ -2034,32 +2166,68 @@ return future<_R>(__h.get()); } +template <class _R, class _F> +future<_R> +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES +__make_async_assoc_state(_F&& __f) +#else +__make_async_assoc_state(_F __f) +#endif +{ + unique_ptr<__async_assoc_state<_R, _F>, __release_shared_count> + __h(new __async_assoc_state<_R, _F>(_STD::forward<_F>(__f))); + _STD::thread(&__async_assoc_state<_R, _F>::__execute, __h.get()).detach(); + return future<_R>(__h.get()); +} + template <class _F, class... _Args> -future<typename result_of<_F(_Args...)>::type> +class __async_func +{ + tuple<_F, _Args...> __f_; + +public: + typedef typename __invoke_of<_F, _Args...>::type _R; + + _LIBCPP_INLINE_VISIBILITY + explicit __async_func(_F&& __f, _Args&&... __args) + : __f_(_STD::move(__f), _STD::move(__args)...) {} + + _LIBCPP_INLINE_VISIBILITY + __async_func(__async_func&& __f) : __f_(_STD::move(__f.__f_)) {} + + _R operator()() + { + typedef typename __make_tuple_indices<1+sizeof...(_Args), 1>::type _Index; + return __execute(_Index()); + } +private: + template <size_t ..._Indices> + _R + __execute(__tuple_indices<_Indices...>) + { + return __invoke(_STD::move(_STD::get<0>(__f_)), _STD::move(_STD::get<_Indices>(__f_))...); + } +}; + +template <class _F, class... _Args> +future<typename __invoke_of<typename decay<_F>::type, typename decay<_Args>::type...>::type> async(launch __policy, _F&& __f, _Args&&... __args) { - typedef typename result_of<_F(_Args...)>::type _R; + typedef __async_func<typename decay<_F>::type, typename decay<_Args>::type...> _BF; + typedef typename _BF::_R _R; future<_R> __r; if (__policy & launch::async) - { - packaged_task<_R()> __pk(bind(_STD::forward<_F>(__f), - _STD::forward<_Args>(__args)...)); - __r = __pk.get_future(); - thread(_STD::move(__pk)).detach(); - } + __r = _STD::__make_async_assoc_state<_R>(_BF(__decay_copy(_STD::forward<_F>(__f)), + __decay_copy(_STD::forward<_Args>(__args))...)); else if (__policy & launch::deferred) - __r = _STD::__make_deferred_assoc_state<_R>(bind(_STD::forward<_F>(__f), - _STD::forward<_Args>(__args)...)); + __r = _STD::__make_deferred_assoc_state<_R>(_BF(__decay_copy(_STD::forward<_F>(__f)), + __decay_copy(_STD::forward<_Args>(__args))...)); return __r; } template <class _F, class... _Args> inline _LIBCPP_INLINE_VISIBILITY -typename enable_if -< - !is_same<typename decay<_F>::type, launch>::value, - future<typename result_of<_F(_Args...)>::type> ->::type +future<typename __invoke_of<typename decay<_F>::type, typename decay<_Args>::type...>::type> async(_F&& __f, _Args&&... __args) { return _STD::async(launch::any, _STD::forward<_F>(__f), 